home *** CD-ROM | disk | FTP | other *** search
/ EnigmA Amiga Run 1995 November / EnigmA AMIGA RUN 02 (1995)(G.R. Edizioni)(IT)[!][issue 1995-11][Skylink CD].iso / earcd / program / gcc / gcc270-s.lha / gcc-2.7.0-amiga / gcc.info-23 (.txt) < prev    next >
GNU Info File  |  1995-06-16  |  51KB  |  897 lines
  1. This is Info file gcc.info, produced by Makeinfo-1.55 from the input
  2. file gcc.texi.
  3.    This file documents the use and the internals of the GNU compiler.
  4.    Published by the Free Software Foundation 59 Temple Place - Suite 330
  5. Boston, MA 02111-1307 USA
  6.    Copyright (C) 1988, 1989, 1992, 1993, 1994, 1995 Free Software
  7. Foundation, Inc.
  8.    Permission is granted to make and distribute verbatim copies of this
  9. manual provided the copyright notice and this permission notice are
  10. preserved on all copies.
  11.    Permission is granted to copy and distribute modified versions of
  12. this manual under the conditions for verbatim copying, provided also
  13. that the sections entitled "GNU General Public License," "Funding for
  14. Free Software," and "Protect Your Freedom--Fight `Look And Feel'" are
  15. included exactly as in the original, and provided that the entire
  16. resulting derived work is distributed under the terms of a permission
  17. notice identical to this one.
  18.    Permission is granted to copy and distribute translations of this
  19. manual into another language, under the above conditions for modified
  20. versions, except that the sections entitled "GNU General Public
  21. License," "Funding for Free Software," and "Protect Your Freedom--Fight
  22. `Look And Feel'", and this permission notice, may be included in
  23. translations approved by the Free Software Foundation instead of in the
  24. original English.
  25. File: gcc.info,  Node: Uninitialized Data,  Next: Label Output,  Prev: Data Output,  Up: Assembler Format
  26. Output of Uninitialized Variables
  27. ---------------------------------
  28.    Each of the macros in this section is used to do the whole job of
  29. outputting a single uninitialized variable.
  30. `ASM_OUTPUT_COMMON (STREAM, NAME, SIZE, ROUNDED)'
  31.      A C statement (sans semicolon) to output to the stdio stream
  32.      STREAM the assembler definition of a common-label named NAME whose
  33.      size is SIZE bytes.  The variable ROUNDED is the size rounded up
  34.      to whatever alignment the caller wants.
  35.      Use the expression `assemble_name (STREAM, NAME)' to output the
  36.      name itself; before and after that, output the additional
  37.      assembler syntax for defining the name, and a newline.
  38.      This macro controls how the assembler definitions of uninitialized
  39.      global variables are output.
  40. `ASM_OUTPUT_ALIGNED_COMMON (STREAM, NAME, SIZE, ALIGNMENT)'
  41.      Like `ASM_OUTPUT_COMMON' except takes the required alignment as a
  42.      separate, explicit argument.  If you define this macro, it is used
  43.      in place of `ASM_OUTPUT_COMMON', and gives you more flexibility in
  44.      handling the required alignment of the variable.  The alignment is
  45.      specified as the number of bits.
  46. `ASM_OUTPUT_SHARED_COMMON (STREAM, NAME, SIZE, ROUNDED)'
  47.      If defined, it is similar to `ASM_OUTPUT_COMMON', except that it
  48.      is used when NAME is shared.  If not defined, `ASM_OUTPUT_COMMON'
  49.      will be used.
  50. `ASM_OUTPUT_LOCAL (STREAM, NAME, SIZE, ROUNDED)'
  51.      A C statement (sans semicolon) to output to the stdio stream
  52.      STREAM the assembler definition of a local-common-label named NAME
  53.      whose size is SIZE bytes.  The variable ROUNDED is the size
  54.      rounded up to whatever alignment the caller wants.
  55.      Use the expression `assemble_name (STREAM, NAME)' to output the
  56.      name itself; before and after that, output the additional
  57.      assembler syntax for defining the name, and a newline.
  58.      This macro controls how the assembler definitions of uninitialized
  59.      static variables are output.
  60. `ASM_OUTPUT_ALIGNED_LOCAL (STREAM, NAME, SIZE, ALIGNMENT)'
  61.      Like `ASM_OUTPUT_LOCAL' except takes the required alignment as a
  62.      separate, explicit argument.  If you define this macro, it is used
  63.      in place of `ASM_OUTPUT_LOCAL', and gives you more flexibility in
  64.      handling the required alignment of the variable.  The alignment is
  65.      specified as the number of bits.
  66. `ASM_OUTPUT_SHARED_LOCAL (STREAM, NAME, SIZE, ROUNDED)'
  67.      If defined, it is similar to `ASM_OUTPUT_LOCAL', except that it is
  68.      used when NAME is shared.  If not defined, `ASM_OUTPUT_LOCAL' will
  69.      be used.
  70. File: gcc.info,  Node: Label Output,  Next: Initialization,  Prev: Uninitialized Data,  Up: Assembler Format
  71. Output and Generation of Labels
  72. -------------------------------
  73.    This is about outputting labels.
  74. `ASM_OUTPUT_LABEL (STREAM, NAME)'
  75.      A C statement (sans semicolon) to output to the stdio stream
  76.      STREAM the assembler definition of a label named NAME.  Use the
  77.      expression `assemble_name (STREAM, NAME)' to output the name
  78.      itself; before and after that, output the additional assembler
  79.      syntax for defining the name, and a newline.
  80. `ASM_DECLARE_FUNCTION_NAME (STREAM, NAME, DECL)'
  81.      A C statement (sans semicolon) to output to the stdio stream
  82.      STREAM any text necessary for declaring the name NAME of a
  83.      function which is being defined.  This macro is responsible for
  84.      outputting the label definition (perhaps using
  85.      `ASM_OUTPUT_LABEL').  The argument DECL is the `FUNCTION_DECL'
  86.      tree node representing the function.
  87.      If this macro is not defined, then the function name is defined in
  88.      the usual manner as a label (by means of `ASM_OUTPUT_LABEL').
  89. `ASM_DECLARE_FUNCTION_SIZE (STREAM, NAME, DECL)'
  90.      A C statement (sans semicolon) to output to the stdio stream
  91.      STREAM any text necessary for declaring the size of a function
  92.      which is being defined.  The argument NAME is the name of the
  93.      function.  The argument DECL is the `FUNCTION_DECL' tree node
  94.      representing the function.
  95.      If this macro is not defined, then the function size is not
  96.      defined.
  97. `ASM_DECLARE_OBJECT_NAME (STREAM, NAME, DECL)'
  98.      A C statement (sans semicolon) to output to the stdio stream
  99.      STREAM any text necessary for declaring the name NAME of an
  100.      initialized variable which is being defined.  This macro must
  101.      output the label definition (perhaps using `ASM_OUTPUT_LABEL').
  102.      The argument DECL is the `VAR_DECL' tree node representing the
  103.      variable.
  104.      If this macro is not defined, then the variable name is defined in
  105.      the usual manner as a label (by means of `ASM_OUTPUT_LABEL').
  106. `ASM_FINISH_DECLARE_OBJECT (STREAM, DECL, TOPLEVEL, ATEND)'
  107.      A C statement (sans semicolon) to finish up declaring a variable
  108.      name once the compiler has processed its initializer fully and
  109.      thus has had a chance to determine the size of an array when
  110.      controlled by an initializer.  This is used on systems where it's
  111.      necessary to declare something about the size of the object.
  112.      If you don't define this macro, that is equivalent to defining it
  113.      to do nothing.
  114. `ASM_GLOBALIZE_LABEL (STREAM, NAME)'
  115.      A C statement (sans semicolon) to output to the stdio stream
  116.      STREAM some commands that will make the label NAME global; that
  117.      is, available for reference from other files.  Use the expression
  118.      `assemble_name (STREAM, NAME)' to output the name itself; before
  119.      and after that, output the additional assembler syntax for making
  120.      that name global, and a newline.
  121. `ASM_WEAKEN_LABEL'
  122.      A C statement (sans semicolon) to output to the stdio stream
  123.      STREAM some commands that will make the label NAME weak; that is,
  124.      available for reference from other files but only used if no other
  125.      definition is available.  Use the expression `assemble_name
  126.      (STREAM, NAME)' to output the name itself; before and after that,
  127.      output the additional assembler syntax for making that name weak,
  128.      and a newline.
  129.      If you don't define this macro, GNU CC will not support weak
  130.      symbols and you should not define the `SUPPORTS_WEAK' macro.
  131. `SUPPORTS_WEAK'
  132.      A C expression which evaluates to true if the target supports weak
  133.      symbols.
  134.      If you don't define this macro, `defaults.h' provides a default
  135.      definition.  If `ASM_WEAKEN_LABEL' is defined, the default
  136.      definition is `1'; otherwise, it is `0'.  Define this macro if you
  137.      want to control weak symbol support with a compiler flag such as
  138.      `-melf'.
  139. `ASM_OUTPUT_EXTERNAL (STREAM, DECL, NAME)'
  140.      A C statement (sans semicolon) to output to the stdio stream
  141.      STREAM any text necessary for declaring the name of an external
  142.      symbol named NAME which is referenced in this compilation but not
  143.      defined.  The value of DECL is the tree node for the declaration.
  144.      This macro need not be defined if it does not need to output
  145.      anything.  The GNU assembler and most Unix assemblers don't
  146.      require anything.
  147. `ASM_OUTPUT_EXTERNAL_LIBCALL (STREAM, SYMREF)'
  148.      A C statement (sans semicolon) to output on STREAM an assembler
  149.      pseudo-op to declare a library function name external.  The name
  150.      of the library function is given by SYMREF, which has type `rtx'
  151.      and is a `symbol_ref'.
  152.      This macro need not be defined if it does not need to output
  153.      anything.  The GNU assembler and most Unix assemblers don't
  154.      require anything.
  155. `ASM_OUTPUT_LABELREF (STREAM, NAME)'
  156.      A C statement (sans semicolon) to output to the stdio stream
  157.      STREAM a reference in assembler syntax to a label named NAME.
  158.      This should add `_' to the front of the name, if that is customary
  159.      on your operating system, as it is in most Berkeley Unix systems.
  160.      This macro is used in `assemble_name'.
  161. `ASM_OUTPUT_INTERNAL_LABEL (STREAM, PREFIX, NUM)'
  162.      A C statement to output to the stdio stream STREAM a label whose
  163.      name is made from the string PREFIX and the number NUM.
  164.      It is absolutely essential that these labels be distinct from the
  165.      labels used for user-level functions and variables.  Otherwise,
  166.      certain programs will have name conflicts with internal labels.
  167.      It is desirable to exclude internal labels from the symbol table
  168.      of the object file.  Most assemblers have a naming convention for
  169.      labels that should be excluded; on many systems, the letter `L' at
  170.      the beginning of a label has this effect.  You should find out what
  171.      convention your system uses, and follow it.
  172.      The usual definition of this macro is as follows:
  173.           fprintf (STREAM, "L%s%d:\n", PREFIX, NUM)
  174. `ASM_GENERATE_INTERNAL_LABEL (STRING, PREFIX, NUM)'
  175.      A C statement to store into the string STRING a label whose name
  176.      is made from the string PREFIX and the number NUM.
  177.      This string, when output subsequently by `assemble_name', should
  178.      produce the output that `ASM_OUTPUT_INTERNAL_LABEL' would produce
  179.      with the same PREFIX and NUM.
  180.      If the string begins with `*', then `assemble_name' will output
  181.      the rest of the string unchanged.  It is often convenient for
  182.      `ASM_GENERATE_INTERNAL_LABEL' to use `*' in this way.  If the
  183.      string doesn't start with `*', then `ASM_OUTPUT_LABELREF' gets to
  184.      output the string, and may change it.  (Of course,
  185.      `ASM_OUTPUT_LABELREF' is also part of your machine description, so
  186.      you should know what it does on your machine.)
  187. `ASM_FORMAT_PRIVATE_NAME (OUTVAR, NAME, NUMBER)'
  188.      A C expression to assign to OUTVAR (which is a variable of type
  189.      `char *') a newly allocated string made from the string NAME and
  190.      the number NUMBER, with some suitable punctuation added.  Use
  191.      `alloca' to get space for the string.
  192.      The string will be used as an argument to `ASM_OUTPUT_LABELREF' to
  193.      produce an assembler label for an internal static variable whose
  194.      name is NAME.  Therefore, the string must be such as to result in
  195.      valid assembler code.  The argument NUMBER is different each time
  196.      this macro is executed; it prevents conflicts between
  197.      similarly-named internal static variables in different scopes.
  198.      Ideally this string should not be a valid C identifier, to prevent
  199.      any conflict with the user's own symbols.  Most assemblers allow
  200.      periods or percent signs in assembler symbols; putting at least
  201.      one of these between the name and the number will suffice.
  202. `ASM_OUTPUT_DEF (STREAM, NAME, VALUE)'
  203.      A C statement to output to the stdio stream STREAM assembler code
  204.      which defines (equates) the symbol NAME to have the value VALUE.
  205.      If SET_ASM_OP is defined, a default definition is provided which is
  206.      correct for most systems.
  207. `OBJC_GEN_METHOD_LABEL (BUF, IS_INST, CLASS_NAME, CAT_NAME, SEL_NAME)'
  208.      Define this macro to override the default assembler names used for
  209.      Objective C methods.
  210.      The default name is a unique method number followed by the name of
  211.      the class (e.g. `_1_Foo').  For methods in categories, the name of
  212.      the category is also included in the assembler name (e.g.
  213.      `_1_Foo_Bar').
  214.      These names are safe on most systems, but make debugging difficult
  215.      since the method's selector is not present in the name.
  216.      Therefore, particular systems define other ways of computing names.
  217.      BUF is an expression of type `char *' which gives you a buffer in
  218.      which to store the name; its length is as long as CLASS_NAME,
  219.      CAT_NAME and SEL_NAME put together, plus 50 characters extra.
  220.      The argument IS_INST specifies whether the method is an instance
  221.      method or a class method; CLASS_NAME is the name of the class;
  222.      CAT_NAME is the name of the category (or NULL if the method is not
  223.      in a category); and SEL_NAME is the name of the selector.
  224.      On systems where the assembler can handle quoted names, you can
  225.      use this macro to provide more human-readable names.
  226. File: gcc.info,  Node: Initialization,  Next: Macros for Initialization,  Prev: Label Output,  Up: Assembler Format
  227. How Initialization Functions Are Handled
  228. ----------------------------------------
  229.    The compiled code for certain languages includes "constructors"
  230. (also called "initialization routines")--functions to initialize data
  231. in the program when the program is started.  These functions need to be
  232. called before the program is "started"--that is to say, before `main'
  233. is called.
  234.    Compiling some languages generates "destructors" (also called
  235. "termination routines") that should be called when the program
  236. terminates.
  237.    To make the initialization and termination functions work, the
  238. compiler must output something in the assembler code to cause those
  239. functions to be called at the appropriate time.  When you port the
  240. compiler to a new system, you need to specify how to do this.
  241.    There are two major ways that GCC currently supports the execution of
  242. initialization and termination functions.  Each way has two variants.
  243. Much of the structure is common to all four variations.
  244.    The linker must build two lists of these functions--a list of
  245. initialization functions, called `__CTOR_LIST__', and a list of
  246. termination functions, called `__DTOR_LIST__'.
  247.    Each list always begins with an ignored function pointer (which may
  248. hold 0, -1, or a count of the function pointers after it, depending on
  249. the environment).  This is followed by a series of zero or more function
  250. pointers to constructors (or destructors), followed by a function
  251. pointer containing zero.
  252.    Depending on the operating system and its executable file format,
  253. either `crtstuff.c' or `libgcc2.c' traverses these lists at startup
  254. time and exit time.  Constructors are called in reverse order of the
  255. list; destructors in forward order.
  256.    The best way to handle static constructors works only for object file
  257. formats which provide arbitrarily-named sections.  A section is set
  258. aside for a list of constructors, and another for a list of destructors.
  259. Traditionally these are called `.ctors' and `.dtors'.  Each object file
  260. that defines an initialization function also puts a word in the
  261. constructor section to point to that function.  The linker accumulates
  262. all these words into one contiguous `.ctors' section.  Termination
  263. functions are handled similarly.
  264.    To use this method, you need appropriate definitions of the macros
  265. `ASM_OUTPUT_CONSTRUCTOR' and `ASM_OUTPUT_DESTRUCTOR'.  Usually you can
  266. get them by including `svr4.h'.
  267.    When arbitrary sections are available, there are two variants,
  268. depending upon how the code in `crtstuff.c' is called.  On systems that
  269. support an "init" section which is executed at program startup, parts
  270. of `crtstuff.c' are compiled into that section.  The program is linked
  271. by the `gcc' driver like this:
  272.      ld -o OUTPUT_FILE crtbegin.o ... crtend.o -lgcc
  273.    The head of a function (`__do_global_ctors') appears in the init
  274. section of `crtbegin.o'; the remainder of the function appears in the
  275. init section of `crtend.o'.  The linker will pull these two parts of
  276. the section together, making a whole function.  If any of the user's
  277. object files linked into the middle of it contribute code, then that
  278. code will be executed as part of the body of `__do_global_ctors'.
  279.    To use this variant, you must define the `INIT_SECTION_ASM_OP' macro
  280. properly.
  281.    If no init section is available, do not define
  282. `INIT_SECTION_ASM_OP'.  Then `__do_global_ctors' is built into the text
  283. section like all other functions, and resides in `libgcc.a'.  When GCC
  284. compiles any function called `main', it inserts a procedure call to
  285. `__main' as the first executable code after the function prologue.  The
  286. `__main' function, also defined in `libgcc2.c', simply calls
  287. `__do_global_ctors'.
  288.    In file formats that don't support arbitrary sections, there are
  289. again two variants.  In the simplest variant, the GNU linker (GNU `ld')
  290. and an `a.out' format must be used.  In this case,
  291. `ASM_OUTPUT_CONSTRUCTOR' is defined to produce a `.stabs' entry of type
  292. `N_SETT', referencing the name `__CTOR_LIST__', and with the address of
  293. the void function containing the initialization code as its value.  The
  294. GNU linker recognizes this as a request to add the value to a "set";
  295. the values are accumulated, and are eventually placed in the executable
  296. as a vector in the format described above, with a leading (ignored)
  297. count and a trailing zero element.  `ASM_OUTPUT_DESTRUCTOR' is handled
  298. similarly.  Since no init section is available, the absence of
  299. `INIT_SECTION_ASM_OP' causes the compilation of `main' to call `__main'
  300. as above, starting the initialization process.
  301.    The last variant uses neither arbitrary sections nor the GNU linker.
  302. This is preferable when you want to do dynamic linking and when using
  303. file formats which the GNU linker does not support, such as `ECOFF'.  In
  304. this case, `ASM_OUTPUT_CONSTRUCTOR' does not produce an `N_SETT'
  305. symbol; initialization and termination functions are recognized simply
  306. by their names.  This requires an extra program in the linkage step,
  307. called `collect2'.  This program pretends to be the linker, for use
  308. with GNU CC; it does its job by running the ordinary linker, but also
  309. arranges to include the vectors of initialization and termination
  310. functions.  These functions are called via `__main' as described above.
  311.    Choosing among these configuration options has been simplified by a
  312. set of operating-system-dependent files in the `config' subdirectory.
  313. These files define all of the relevant parameters.  Usually it is
  314. sufficient to include one into your specific machine-dependent
  315. configuration file.  These files are:
  316. `aoutos.h'
  317.      For operating systems using the `a.out' format.
  318. `next.h'
  319.      For operating systems using the `MachO' format.
  320. `svr3.h'
  321.      For System V Release 3 and similar systems using `COFF' format.
  322. `svr4.h'
  323.      For System V Release 4 and similar systems using `ELF' format.
  324. `vms.h'
  325.      For the VMS operating system.
  326.    The following section describes the specific macros that control and
  327. customize the handling of initialization and termination functions.
  328. File: gcc.info,  Node: Macros for Initialization,  Next: Instruction Output,  Prev: Initialization,  Up: Assembler Format
  329. Macros Controlling Initialization Routines
  330. ------------------------------------------
  331.    Here are the macros that control how the compiler handles
  332. initialization and termination functions:
  333. `INIT_SECTION_ASM_OP'
  334.      If defined, a C string constant for the assembler operation to
  335.      identify the following data as initialization code.  If not
  336.      defined, GNU CC will assume such a section does not exist.  When
  337.      you are using special sections for initialization and termination
  338.      functions, this macro also controls how `crtstuff.c' and
  339.      `libgcc2.c' arrange to run the initialization functions.
  340. `HAS_INIT_SECTION'
  341.      If defined, `main' will not call `__main' as described above.
  342.      This macro should be defined for systems that control the contents
  343.      of the init section on a symbol-by-symbol basis, such as OSF/1,
  344.      and should not be defined explicitly for systems that support
  345.      `INIT_SECTION_ASM_OP'.
  346. `LD_INIT_SWITCH'
  347.      If defined, a C string constant for a switch that tells the linker
  348.      that the following symbol is an initialization routine.
  349. `LD_FINI_SWITCH'
  350.      If defined, a C string constant for a switch that tells the linker
  351.      that the following symbol is a finalization routine.
  352. `INVOKE__main'
  353.      If defined, `main' will call `__main' despite the presence of
  354.      `INIT_SECTION_ASM_OP'.  This macro should be defined for systems
  355.      where the init section is not actually run automatically, but is
  356.      still useful for collecting the lists of constructors and
  357.      destructors.
  358. `ASM_OUTPUT_CONSTRUCTOR (STREAM, NAME)'
  359.      Define this macro as a C statement to output on the stream STREAM
  360.      the assembler code to arrange to call the function named NAME at
  361.      initialization time.
  362.      Assume that NAME is the name of a C function generated
  363.      automatically by the compiler.  This function takes no arguments.
  364.      Use the function `assemble_name' to output the name NAME; this
  365.      performs any system-specific syntactic transformations such as
  366.      adding an underscore.
  367.      If you don't define this macro, nothing special is output to
  368.      arrange to call the function.  This is correct when the function
  369.      will be called in some other manner--for example, by means of the
  370.      `collect2' program, which looks through the symbol table to find
  371.      these functions by their names.
  372. `ASM_OUTPUT_DESTRUCTOR (STREAM, NAME)'
  373.      This is like `ASM_OUTPUT_CONSTRUCTOR' but used for termination
  374.      functions rather than initialization functions.
  375.    If your system uses `collect2' as the means of processing
  376. constructors, then that program normally uses `nm' to scan an object
  377. file for constructor functions to be called.  On certain kinds of
  378. systems, you can define these macros to make `collect2' work faster
  379. (and, in some cases, make it work at all):
  380. `OBJECT_FORMAT_COFF'
  381.      Define this macro if the system uses COFF (Common Object File
  382.      Format) object files, so that `collect2' can assume this format
  383.      and scan object files directly for dynamic constructor/destructor
  384.      functions.
  385. `OBJECT_FORMAT_ROSE'
  386.      Define this macro if the system uses ROSE format object files, so
  387.      that `collect2' can assume this format and scan object files
  388.      directly for dynamic constructor/destructor functions.
  389.      These macros are effective only in a native compiler; `collect2' as
  390.      part of a cross compiler always uses `nm' for the target machine.
  391. `REAL_NM_FILE_NAME'
  392.      Define this macro as a C string constant containing the file name
  393.      to use to execute `nm'.  The default is to search the path
  394.      normally for `nm'.
  395.      If your system supports shared libraries and has a program to list
  396.      the dynamic dependencies of a given library or executable, you can
  397.      define these macros to enable support for running initialization
  398.      and termination functions in shared libraries:
  399. `LDD_SUFFIX'
  400.      Define this macro to a C string constant containing the name of the
  401.      program which lists dynamic dependencies, like `"ldd"' under SunOS
  402.      4.
  403. `PARSE_LDD_OUTPUT (PTR)'
  404.      Define this macro to be C code that extracts filenames from the
  405.      output of the program denoted by `LDD_SUFFIX'.  PTR is a variable
  406.      of type `char *' that points to the beginning of a line of output
  407.      from `LDD_SUFFIX'.  If the line lists a dynamic dependency, the
  408.      code must advance PTR to the beginning of the filename on that
  409.      line.  Otherwise, it must set PTR to `NULL'.
  410. File: gcc.info,  Node: Instruction Output,  Next: Dispatch Tables,  Prev: Macros for Initialization,  Up: Assembler Format
  411. Output of Assembler Instructions
  412. --------------------------------
  413.    This describes assembler instruction output.
  414. `REGISTER_NAMES'
  415.      A C initializer containing the assembler's names for the machine
  416.      registers, each one as a C string constant.  This is what
  417.      translates register numbers in the compiler into assembler
  418.      language.
  419. `ADDITIONAL_REGISTER_NAMES'
  420.      If defined, a C initializer for an array of structures containing
  421.      a name and a register number.  This macro defines additional names
  422.      for hard registers, thus allowing the `asm' option in declarations
  423.      to refer to registers using alternate names.
  424. `ASM_OUTPUT_OPCODE (STREAM, PTR)'
  425.      Define this macro if you are using an unusual assembler that
  426.      requires different names for the machine instructions.
  427.      The definition is a C statement or statements which output an
  428.      assembler instruction opcode to the stdio stream STREAM.  The
  429.      macro-operand PTR is a variable of type `char *' which points to
  430.      the opcode name in its "internal" form--the form that is written
  431.      in the machine description.  The definition should output the
  432.      opcode name to STREAM, performing any translation you desire, and
  433.      increment the variable PTR to point at the end of the opcode so
  434.      that it will not be output twice.
  435.      In fact, your macro definition may process less than the entire
  436.      opcode name, or more than the opcode name; but if you want to
  437.      process text that includes `%'-sequences to substitute operands,
  438.      you must take care of the substitution yourself.  Just be sure to
  439.      increment PTR over whatever text should not be output normally.
  440.      If you need to look at the operand values, they can be found as the
  441.      elements of `recog_operand'.
  442.      If the macro definition does nothing, the instruction is output in
  443.      the usual way.
  444. `FINAL_PRESCAN_INSN (INSN, OPVEC, NOPERANDS)'
  445.      If defined, a C statement to be executed just prior to the output
  446.      of assembler code for INSN, to modify the extracted operands so
  447.      they will be output differently.
  448.      Here the argument OPVEC is the vector containing the operands
  449.      extracted from INSN, and NOPERANDS is the number of elements of
  450.      the vector which contain meaningful data for this insn.  The
  451.      contents of this vector are what will be used to convert the insn
  452.      template into assembler code, so you can change the assembler
  453.      output by changing the contents of the vector.
  454.      This macro is useful when various assembler syntaxes share a single
  455.      file of instruction patterns; by defining this macro differently,
  456.      you can cause a large class of instructions to be output
  457.      differently (such as with rearranged operands).  Naturally,
  458.      variations in assembler syntax affecting individual insn patterns
  459.      ought to be handled by writing conditional output routines in
  460.      those patterns.
  461.      If this macro is not defined, it is equivalent to a null statement.
  462. `PRINT_OPERAND (STREAM, X, CODE)'
  463.      A C compound statement to output to stdio stream STREAM the
  464.      assembler syntax for an instruction operand X.  X is an RTL
  465.      expression.
  466.      CODE is a value that can be used to specify one of several ways of
  467.      printing the operand.  It is used when identical operands must be
  468.      printed differently depending on the context.  CODE comes from the
  469.      `%' specification that was used to request printing of the
  470.      operand.  If the specification was just `%DIGIT' then CODE is 0;
  471.      if the specification was `%LTR DIGIT' then CODE is the ASCII code
  472.      for LTR.
  473.      If X is a register, this macro should print the register's name.
  474.      The names can be found in an array `reg_names' whose type is `char
  475.      *[]'.  `reg_names' is initialized from `REGISTER_NAMES'.
  476.      When the machine description has a specification `%PUNCT' (a `%'
  477.      followed by a punctuation character), this macro is called with a
  478.      null pointer for X and the punctuation character for CODE.
  479. `PRINT_OPERAND_PUNCT_VALID_P (CODE)'
  480.      A C expression which evaluates to true if CODE is a valid
  481.      punctuation character for use in the `PRINT_OPERAND' macro.  If
  482.      `PRINT_OPERAND_PUNCT_VALID_P' is not defined, it means that no
  483.      punctuation characters (except for the standard one, `%') are used
  484.      in this way.
  485. `PRINT_OPERAND_ADDRESS (STREAM, X)'
  486.      A C compound statement to output to stdio stream STREAM the
  487.      assembler syntax for an instruction operand that is a memory
  488.      reference whose address is X.  X is an RTL expression.
  489.      On some machines, the syntax for a symbolic address depends on the
  490.      section that the address refers to.  On these machines, define the
  491.      macro `ENCODE_SECTION_INFO' to store the information into the
  492.      `symbol_ref', and then check for it here.  *Note Assembler
  493.      Format::.
  494. `DBR_OUTPUT_SEQEND(FILE)'
  495.      A C statement, to be executed after all slot-filler instructions
  496.      have been output.  If necessary, call `dbr_sequence_length' to
  497.      determine the number of slots filled in a sequence (zero if not
  498.      currently outputting a sequence), to decide how many no-ops to
  499.      output, or whatever.
  500.      Don't define this macro if it has nothing to do, but it is helpful
  501.      in reading assembly output if the extent of the delay sequence is
  502.      made explicit (e.g. with white space).
  503.      Note that output routines for instructions with delay slots must be
  504.      prepared to deal with not being output as part of a sequence (i.e.
  505.      when the scheduling pass is not run, or when no slot fillers could
  506.      be found.)  The variable `final_sequence' is null when not
  507.      processing a sequence, otherwise it contains the `sequence' rtx
  508.      being output.
  509. `REGISTER_PREFIX'
  510. `LOCAL_LABEL_PREFIX'
  511. `USER_LABEL_PREFIX'
  512. `IMMEDIATE_PREFIX'
  513.      If defined, C string expressions to be used for the `%R', `%L',
  514.      `%U', and `%I' options of `asm_fprintf' (see `final.c').  These
  515.      are useful when a single `md' file must support multiple assembler
  516.      formats.  In that case, the various `tm.h' files can define these
  517.      macros differently.
  518. `ASSEMBLER_DIALECT'
  519.      If your target supports multiple dialects of assembler language
  520.      (such as different opcodes), define this macro as a C expression
  521.      that gives the numeric index of the assembler language dialect to
  522.      use, with zero as the first variant.
  523.      If this macro is defined, you may use
  524.      `{option0|option1|option2...}' constructs in the output templates
  525.      of patterns (*note Output Template::.) or in the first argument of
  526.      `asm_fprintf'.  This construct outputs `option0', `option1' or
  527.      `option2', etc., if the value of `ASSEMBLER_DIALECT' is zero, one
  528.      or two, etc.  Any special characters within these strings retain
  529.      their usual meaning.
  530.      If you do not define this macro, the characters `{', `|' and `}'
  531.      do not have any special meaning when used in templates or operands
  532.      to `asm_fprintf'.
  533.      Define the macros `REGISTER_PREFIX', `LOCAL_LABEL_PREFIX',
  534.      `USER_LABEL_PREFIX' and `IMMEDIATE_PREFIX' if you can express the
  535.      variations in assemble language syntax with that mechanism.  Define
  536.      `ASSEMBLER_DIALECT' and use the `{option0|option1}' syntax if the
  537.      syntax variant are larger and involve such things as different
  538.      opcodes or operand order.
  539. `ASM_OUTPUT_REG_PUSH (STREAM, REGNO)'
  540.      A C expression to output to STREAM some assembler code which will
  541.      push hard register number REGNO onto the stack.  The code need not
  542.      be optimal, since this macro is used only when profiling.
  543. `ASM_OUTPUT_REG_POP (STREAM, REGNO)'
  544.      A C expression to output to STREAM some assembler code which will
  545.      pop hard register number REGNO off of the stack.  The code need
  546.      not be optimal, since this macro is used only when profiling.
  547. File: gcc.info,  Node: Dispatch Tables,  Next: Alignment Output,  Prev: Instruction Output,  Up: Assembler Format
  548. Output of Dispatch Tables
  549. -------------------------
  550.    This concerns dispatch tables.
  551. `ASM_OUTPUT_ADDR_DIFF_ELT (STREAM, VALUE, REL)'
  552.      This macro should be provided on machines where the addresses in a
  553.      dispatch table are relative to the table's own address.
  554.      The definition should be a C statement to output to the stdio
  555.      stream STREAM an assembler pseudo-instruction to generate a
  556.      difference between two labels.  VALUE and REL are the numbers of
  557.      two internal labels.  The definitions of these labels are output
  558.      using `ASM_OUTPUT_INTERNAL_LABEL', and they must be printed in the
  559.      same way here.  For example,
  560.           fprintf (STREAM, "\t.word L%d-L%d\n",
  561.                    VALUE, REL)
  562. `ASM_OUTPUT_ADDR_VEC_ELT (STREAM, VALUE)'
  563.      This macro should be provided on machines where the addresses in a
  564.      dispatch table are absolute.
  565.      The definition should be a C statement to output to the stdio
  566.      stream STREAM an assembler pseudo-instruction to generate a
  567.      reference to a label.  VALUE is the number of an internal label
  568.      whose definition is output using `ASM_OUTPUT_INTERNAL_LABEL'.  For
  569.      example,
  570.           fprintf (STREAM, "\t.word L%d\n", VALUE)
  571. `ASM_OUTPUT_CASE_LABEL (STREAM, PREFIX, NUM, TABLE)'
  572.      Define this if the label before a jump-table needs to be output
  573.      specially.  The first three arguments are the same as for
  574.      `ASM_OUTPUT_INTERNAL_LABEL'; the fourth argument is the jump-table
  575.      which follows (a `jump_insn' containing an `addr_vec' or
  576.      `addr_diff_vec').
  577.      This feature is used on system V to output a `swbeg' statement for
  578.      the table.
  579.      If this macro is not defined, these labels are output with
  580.      `ASM_OUTPUT_INTERNAL_LABEL'.
  581. `ASM_OUTPUT_CASE_END (STREAM, NUM, TABLE)'
  582.      Define this if something special must be output at the end of a
  583.      jump-table.  The definition should be a C statement to be executed
  584.      after the assembler code for the table is written.  It should write
  585.      the appropriate code to stdio stream STREAM.  The argument TABLE
  586.      is the jump-table insn, and NUM is the label-number of the
  587.      preceding label.
  588.      If this macro is not defined, nothing special is output at the end
  589.      of the jump-table.
  590. File: gcc.info,  Node: Alignment Output,  Prev: Dispatch Tables,  Up: Assembler Format
  591. Assembler Commands for Alignment
  592. --------------------------------
  593.    This describes commands for alignment.
  594. `ASM_OUTPUT_ALIGN_CODE (FILE)'
  595.      A C expression to output text to align the location counter in the
  596.      way that is desirable at a point in the code that is reached only
  597.      by jumping.
  598.      This macro need not be defined if you don't want any special
  599.      alignment to be done at such a time.  Most machine descriptions do
  600.      not currently define the macro.
  601. `ASM_OUTPUT_LOOP_ALIGN (FILE)'
  602.      A C expression to output text to align the location counter in the
  603.      way that is desirable at the beginning of a loop.
  604.      This macro need not be defined if you don't want any special
  605.      alignment to be done at such a time.  Most machine descriptions do
  606.      not currently define the macro.
  607. `ASM_OUTPUT_SKIP (STREAM, NBYTES)'
  608.      A C statement to output to the stdio stream STREAM an assembler
  609.      instruction to advance the location counter by NBYTES bytes.
  610.      Those bytes should be zero when loaded.  NBYTES will be a C
  611.      expression of type `int'.
  612. `ASM_NO_SKIP_IN_TEXT'
  613.      Define this macro if `ASM_OUTPUT_SKIP' should not be used in the
  614.      text section because it fails put zeros in the bytes that are
  615.      skipped.  This is true on many Unix systems, where the pseudo-op
  616.      to skip bytes produces no-op instructions rather than zeros when
  617.      used in the text section.
  618. `ASM_OUTPUT_ALIGN (STREAM, POWER)'
  619.      A C statement to output to the stdio stream STREAM an assembler
  620.      command to advance the location counter to a multiple of 2 to the
  621.      POWER bytes.  POWER will be a C expression of type `int'.
  622. File: gcc.info,  Node: Debugging Info,  Next: Cross-compilation,  Prev: Assembler Format,  Up: Target Macros
  623. Controlling Debugging Information Format
  624. ========================================
  625.    This describes how to specify debugging information.
  626. * Menu:
  627. * All Debuggers::      Macros that affect all debugging formats uniformly.
  628. * DBX Options::        Macros enabling specific options in DBX format.
  629. * DBX Hooks::          Hook macros for varying DBX format.
  630. * File Names and DBX:: Macros controlling output of file names in DBX format.
  631. * SDB and DWARF::      Macros for SDB (COFF) and DWARF formats.
  632. File: gcc.info,  Node: All Debuggers,  Next: DBX Options,  Up: Debugging Info
  633. Macros Affecting All Debugging Formats
  634. --------------------------------------
  635.    These macros affect all debugging formats.
  636. `DBX_REGISTER_NUMBER (REGNO)'
  637.      A C expression that returns the DBX register number for the
  638.      compiler register number REGNO.  In simple cases, the value of this
  639.      expression may be REGNO itself.  But sometimes there are some
  640.      registers that the compiler knows about and DBX does not, or vice
  641.      versa.  In such cases, some register may need to have one number in
  642.      the compiler and another for DBX.
  643.      If two registers have consecutive numbers inside GNU CC, and they
  644.      can be used as a pair to hold a multiword value, then they *must*
  645.      have consecutive numbers after renumbering with
  646.      `DBX_REGISTER_NUMBER'.  Otherwise, debuggers will be unable to
  647.      access such a pair, because they expect register pairs to be
  648.      consecutive in their own numbering scheme.
  649.      If you find yourself defining `DBX_REGISTER_NUMBER' in way that
  650.      does not preserve register pairs, then what you must do instead is
  651.      redefine the actual register numbering scheme.
  652. `DEBUGGER_AUTO_OFFSET (X)'
  653.      A C expression that returns the integer offset value for an
  654.      automatic variable having address X (an RTL expression).  The
  655.      default computation assumes that X is based on the frame-pointer
  656.      and gives the offset from the frame-pointer.  This is required for
  657.      targets that produce debugging output for DBX or COFF-style
  658.      debugging output for SDB and allow the frame-pointer to be
  659.      eliminated when the `-g' options is used.
  660. `DEBUGGER_ARG_OFFSET (OFFSET, X)'
  661.      A C expression that returns the integer offset value for an
  662.      argument having address X (an RTL expression).  The nominal offset
  663.      is OFFSET.
  664. `PREFERRED_DEBUGGING_TYPE'
  665.      A C expression that returns the type of debugging output GNU CC
  666.      produces when the user specifies `-g' or `-ggdb'.  Define this if
  667.      you have arranged for GNU CC to support more than one format of
  668.      debugging output.  Currently, the allowable values are `DBX_DEBUG',
  669.      `SDB_DEBUG', `DWARF_DEBUG', and `XCOFF_DEBUG'.
  670.      The value of this macro only affects the default debugging output;
  671.      the user can always get a specific type of output by using
  672.      `-gstabs', `-gcoff', `-gdwarf', or `-gxcoff'.
  673. File: gcc.info,  Node: DBX Options,  Next: DBX Hooks,  Prev: All Debuggers,  Up: Debugging Info
  674. Specific Options for DBX Output
  675. -------------------------------
  676.    These are specific options for DBX output.
  677. `DBX_DEBUGGING_INFO'
  678.      Define this macro if GNU CC should produce debugging output for DBX
  679.      in response to the `-g' option.
  680. `XCOFF_DEBUGGING_INFO'
  681.      Define this macro if GNU CC should produce XCOFF format debugging
  682.      output in response to the `-g' option.  This is a variant of DBX
  683.      format.
  684. `DEFAULT_GDB_EXTENSIONS'
  685.      Define this macro to control whether GNU CC should by default
  686.      generate GDB's extended version of DBX debugging information
  687.      (assuming DBX-format debugging information is enabled at all).  If
  688.      you don't define the macro, the default is 1: always generate the
  689.      extended information if there is any occasion to.
  690. `DEBUG_SYMS_TEXT'
  691.      Define this macro if all `.stabs' commands should be output while
  692.      in the text section.
  693. `ASM_STABS_OP'
  694.      A C string constant naming the assembler pseudo op to use instead
  695.      of `.stabs' to define an ordinary debugging symbol.  If you don't
  696.      define this macro, `.stabs' is used.  This macro applies only to
  697.      DBX debugging information format.
  698. `ASM_STABD_OP'
  699.      A C string constant naming the assembler pseudo op to use instead
  700.      of `.stabd' to define a debugging symbol whose value is the current
  701.      location.  If you don't define this macro, `.stabd' is used.  This
  702.      macro applies only to DBX debugging information format.
  703. `ASM_STABN_OP'
  704.      A C string constant naming the assembler pseudo op to use instead
  705.      of `.stabn' to define a debugging symbol with no name.  If you
  706.      don't define this macro, `.stabn' is used.  This macro applies
  707.      only to DBX debugging information format.
  708. `DBX_NO_XREFS'
  709.      Define this macro if DBX on your system does not support the
  710.      construct `xsTAGNAME'.  On some systems, this construct is used to
  711.      describe a forward reference to a structure named TAGNAME.  On
  712.      other systems, this construct is not supported at all.
  713. `DBX_CONTIN_LENGTH'
  714.      A symbol name in DBX-format debugging information is normally
  715.      continued (split into two separate `.stabs' directives) when it
  716.      exceeds a certain length (by default, 80 characters).  On some
  717.      operating systems, DBX requires this splitting; on others,
  718.      splitting must not be done.  You can inhibit splitting by defining
  719.      this macro with the value zero.  You can override the default
  720.      splitting-length by defining this macro as an expression for the
  721.      length you desire.
  722. `DBX_CONTIN_CHAR'
  723.      Normally continuation is indicated by adding a `\' character to
  724.      the end of a `.stabs' string when a continuation follows.  To use
  725.      a different character instead, define this macro as a character
  726.      constant for the character you want to use.  Do not define this
  727.      macro if backslash is correct for your system.
  728. `DBX_STATIC_STAB_DATA_SECTION'
  729.      Define this macro if it is necessary to go to the data section
  730.      before outputting the `.stabs' pseudo-op for a non-global static
  731.      variable.
  732. `DBX_TYPE_DECL_STABS_CODE'
  733.      The value to use in the "code" field of the `.stabs' directive for
  734.      a typedef.  The default is `N_LSYM'.
  735. `DBX_STATIC_CONST_VAR_CODE'
  736.      The value to use in the "code" field of the `.stabs' directive for
  737.      a static variable located in the text section.  DBX format does not
  738.      provide any "right" way to do this.  The default is `N_FUN'.
  739. `DBX_REGPARM_STABS_CODE'
  740.      The value to use in the "code" field of the `.stabs' directive for
  741.      a parameter passed in registers.  DBX format does not provide any
  742.      "right" way to do this.  The default is `N_RSYM'.
  743. `DBX_REGPARM_STABS_LETTER'
  744.      The letter to use in DBX symbol data to identify a symbol as a
  745.      parameter passed in registers.  DBX format does not customarily
  746.      provide any way to do this.  The default is `'P''.
  747. `DBX_MEMPARM_STABS_LETTER'
  748.      The letter to use in DBX symbol data to identify a symbol as a
  749.      stack parameter.  The default is `'p''.
  750. `DBX_FUNCTION_FIRST'
  751.      Define this macro if the DBX information for a function and its
  752.      arguments should precede the assembler code for the function.
  753.      Normally, in DBX format, the debugging information entirely
  754.      follows the assembler code.
  755. `DBX_LBRAC_FIRST'
  756.      Define this macro if the `N_LBRAC' symbol for a block should
  757.      precede the debugging information for variables and functions
  758.      defined in that block.  Normally, in DBX format, the `N_LBRAC'
  759.      symbol comes first.
  760. `DBX_BLOCKS_FUNCTION_RELATIVE'
  761.      Define this macro if the value of a symbol describing the scope of
  762.      a block (`N_LBRAC' or `N_RBRAC') should be relative to the start
  763.      of the enclosing function.  Normally, GNU C uses an absolute
  764.      address.
  765. File: gcc.info,  Node: DBX Hooks,  Next: File Names and DBX,  Prev: DBX Options,  Up: Debugging Info
  766. Open-Ended Hooks for DBX Format
  767. -------------------------------
  768.    These are hooks for DBX format.
  769. `DBX_OUTPUT_LBRAC (STREAM, NAME)'
  770.      Define this macro to say how to output to STREAM the debugging
  771.      information for the start of a scope level for variable names.  The
  772.      argument NAME is the name of an assembler symbol (for use with
  773.      `assemble_name') whose value is the address where the scope begins.
  774. `DBX_OUTPUT_RBRAC (STREAM, NAME)'
  775.      Like `DBX_OUTPUT_LBRAC', but for the end of a scope level.
  776. `DBX_OUTPUT_ENUM (STREAM, TYPE)'
  777.      Define this macro if the target machine requires special handling
  778.      to output an enumeration type.  The definition should be a C
  779.      statement (sans semicolon) to output the appropriate information
  780.      to STREAM for the type TYPE.
  781. `DBX_OUTPUT_FUNCTION_END (STREAM, FUNCTION)'
  782.      Define this macro if the target machine requires special output at
  783.      the end of the debugging information for a function.  The
  784.      definition should be a C statement (sans semicolon) to output the
  785.      appropriate information to STREAM.  FUNCTION is the
  786.      `FUNCTION_DECL' node for the function.
  787. `DBX_OUTPUT_STANDARD_TYPES (SYMS)'
  788.      Define this macro if you need to control the order of output of the
  789.      standard data types at the beginning of compilation.  The argument
  790.      SYMS is a `tree' which is a chain of all the predefined global
  791.      symbols, including names of data types.
  792.      Normally, DBX output starts with definitions of the types for
  793.      integers and characters, followed by all the other predefined
  794.      types of the particular language in no particular order.
  795.      On some machines, it is necessary to output different particular
  796.      types first.  To do this, define `DBX_OUTPUT_STANDARD_TYPES' to
  797.      output those symbols in the necessary order.  Any predefined types
  798.      that you don't explicitly output will be output afterward in no
  799.      particular order.
  800.      Be careful not to define this macro so that it works only for C.
  801.      There are no global variables to access most of the built-in
  802.      types, because another language may have another set of types.
  803.      The way to output a particular type is to look through SYMS to see
  804.      if you can find it.  Here is an example:
  805.           {
  806.             tree decl;
  807.             for (decl = syms; decl; decl = TREE_CHAIN (decl))
  808.               if (!strcmp (IDENTIFIER_POINTER (DECL_NAME (decl)),
  809.                            "long int"))
  810.                 dbxout_symbol (decl);
  811.             ...
  812.           }
  813.      This does nothing if the expected type does not exist.
  814.      See the function `init_decl_processing' in `c-decl.c' to find the
  815.      names to use for all the built-in C types.
  816.      Here is another way of finding a particular type:
  817.           {
  818.             tree decl;
  819.             for (decl = syms; decl; decl = TREE_CHAIN (decl))
  820.               if (TREE_CODE (decl) == TYPE_DECL
  821.                   && (TREE_CODE (TREE_TYPE (decl))
  822.                       == INTEGER_CST)
  823.                   && TYPE_PRECISION (TREE_TYPE (decl)) == 16
  824.                   && TYPE_UNSIGNED (TREE_TYPE (decl)))
  825.           /* This must be `unsigned short'.  */
  826.                 dbxout_symbol (decl);
  827.             ...
  828.           }
  829. File: gcc.info,  Node: File Names and DBX,  Next: SDB and DWARF,  Prev: DBX Hooks,  Up: Debugging Info
  830. File Names in DBX Format
  831. ------------------------
  832.    This describes file names in DBX format.
  833. `DBX_WORKING_DIRECTORY'
  834.      Define this if DBX wants to have the current directory recorded in
  835.      each object file.
  836.      Note that the working directory is always recorded if GDB
  837.      extensions are enabled.
  838. `DBX_OUTPUT_MAIN_SOURCE_FILENAME (STREAM, NAME)'
  839.      A C statement to output DBX debugging information to the stdio
  840.      stream STREAM which indicates that file NAME is the main source
  841.      file--the file specified as the input file for compilation.  This
  842.      macro is called only once, at the beginning of compilation.
  843.      This macro need not be defined if the standard form of output for
  844.      DBX debugging information is appropriate.
  845. `DBX_OUTPUT_MAIN_SOURCE_DIRECTORY (STREAM, NAME)'
  846.      A C statement to output DBX debugging information to the stdio
  847.      stream STREAM which indicates that the current directory during
  848.      compilation is named NAME.
  849.      This macro need not be defined if the standard form of output for
  850.      DBX debugging information is appropriate.
  851. `DBX_OUTPUT_MAIN_SOURCE_FILE_END (STREAM, NAME)'
  852.      A C statement to output DBX debugging information at the end of
  853.      compilation of the main source file NAME.
  854.      If you don't define this macro, nothing special is output at the
  855.      end of compilation, which is correct for most machines.
  856. `DBX_OUTPUT_SOURCE_FILENAME (STREAM, NAME)'
  857.      A C statement to output DBX debugging information to the stdio
  858.      stream STREAM which indicates that file NAME is the current source
  859.      file.  This output is generated each time input shifts to a
  860.      different source file as a result of `#include', the end of an
  861.      included file, or a `#line' command.
  862.      This macro need not be defined if the standard form of output for
  863.      DBX debugging information is appropriate.
  864. File: gcc.info,  Node: SDB and DWARF,  Prev: File Names and DBX,  Up: Debugging Info
  865. Macros for SDB and DWARF Output
  866. -------------------------------
  867.    Here are macros for SDB and DWARF output.
  868. `SDB_DEBUGGING_INFO'
  869.      Define this macro if GNU CC should produce COFF-style debugging
  870.      output for SDB in response to the `-g' option.
  871. `DWARF_DEBUGGING_INFO'
  872.      Define this macro if GNU CC should produce dwarf format debugging
  873.      output in response to the `-g' option.
  874. `PUT_SDB_...'
  875.      Define these macros to override the assembler syntax for the
  876.      special SDB assembler directives.  See `sdbout.c' for a list of
  877.      these macros and their arguments.  If the standard syntax is used,
  878.      you need not define them yourself.
  879. `SDB_DELIM'
  880.      Some assemblers do not support a semicolon as a delimiter, even
  881.      between SDB assembler directives.  In that case, define this macro
  882.      to be the delimiter to use (usually `\n').  It is not necessary to
  883.      define a new set of `PUT_SDB_OP' macros if this is the only change
  884.      required.
  885. `SDB_GENERATE_FAKE'
  886.      Define this macro to override the usual method of constructing a
  887.      dummy name for anonymous structure and union types.  See
  888.      `sdbout.c' for more information.
  889. `SDB_ALLOW_UNKNOWN_REFERENCES'
  890.      Define this macro to allow references to unknown structure, union,
  891.      or enumeration tags to be emitted.  Standard COFF does not allow
  892.      handling of unknown references, MIPS ECOFF has support for it.
  893. `SDB_ALLOW_FORWARD_REFERENCES'
  894.      Define this macro to allow references to structure, union, or
  895.      enumeration tags that have not yet been seen to be handled.  Some
  896.      assemblers choke if forward tags are used, while some require it.
  897.